package com.aerospike.client;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

import com.aerospike.client.Value;

/**
 * Unit tests for Value.toString() focusing on FloatValue behavior.
 *
 * Note: These tests rely on the Value.get(float) factory method to obtain
 * a concrete Value instance that represents a float (FloatValue).
 */
public class ValueTest {
	private Value instance;

	@Before
	public void setUp() {
		// Use a concrete Value instance produced by the library factory.
		// This avoids extending the abstract Value class ourselves.
		instance = Value.get(1.23f);
	}

	@Test
	public void testSetUpInstance_ToString_ReturnsExpectedFloatString() {
		assertEquals(Float.toString(1.23f), instance.toString());
	}

	@Test
	public void testTypicalFloat_ToString_ReturnsFloatRepresentation() {
		float input = 3.14f;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testZero_ToString_ReturnsZeroString() {
		float input = 0.0f;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testNegativeZero_ToString_ReturnsNegativeZeroString() {
		float input = -0.0f;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testNaN_ToString_ReturnsNaN() {
		float input = Float.NaN;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testPositiveInfinity_ToString_ReturnsInfinity() {
		float input = Float.POSITIVE_INFINITY;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testNegativeInfinity_ToString_ReturnsNegativeInfinity() {
		float input = Float.NEGATIVE_INFINITY;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testMaxValue_ToString_ReturnsMaxValueString() {
		float input = Float.MAX_VALUE;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testMinValue_ToString_ReturnsMinValueString() {
		// Float.MIN_VALUE is the smallest positive non-zero value
		float input = Float.MIN_VALUE;
		Value v = Value.get(input);
		assertEquals(Float.toString(input), v.toString());
	}

	@Test
	public void testLargeScale_ToString_AllValuesMatchFloatToString() {
		// Moderate large-scale test to verify stability across many instances.
		// Keep count reasonable for unit test environments.
		final int COUNT = 10000;
		for (int i = 0; i < COUNT; i++) {
			float input = i + 0.125f; // vary fractional part to avoid integer formatting
			Value v = Value.get(input);
			assertEquals("Mismatch at index " + i, Float.toString(input), v.toString());
		}
	}
}

package com.aerospike.client;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

import com.aerospike.client.Value;

/**
 * Unit tests for com.aerospike.client.Value.FloatValue.toString()
 */
public class ValueTest {
    private Value instance;

    @Before
    public void setUp() {
        // Default instance used by some tests
        instance = new Value.FloatValue(1.23f);
    }

    @Test
    public void testTypicalFloat_ReturnsDecimalString() {
        // Arrange: instance created in setUp() with 1.23f
        // Act
        String result = instance.toString();
        // Assert
        assertEquals("1.23", result);
    }

    @Test
    public void testZero_ReturnsZeroPointZero() {
        Value zero = new Value.FloatValue(0.0f);
        assertEquals("0.0", zero.toString());
    }

    @Test
    public void testNegativeZero_PreservesSign() {
        Value negZero = new Value.FloatValue(-0.0f);
        assertEquals("-0.0", negZero.toString());
    }

    @Test
    public void testNaN_ReturnsNaN() {
        Value nan = new Value.FloatValue(Float.NaN);
        assertEquals("NaN", nan.toString());
    }

    @Test
    public void testPositiveInfinity_ReturnsInfinity() {
        Value inf = new Value.FloatValue(Float.POSITIVE_INFINITY);
        assertEquals("Infinity", inf.toString());
    }

    @Test
    public void testNegativeInfinity_ReturnsNegativeInfinity() {
        Value ninf = new Value.FloatValue(Float.NEGATIVE_INFINITY);
        assertEquals("-Infinity", ninf.toString());
    }

    @Test
    public void testMaxValue_ReturnsExpectedString() {
        Value max = new Value.FloatValue(Float.MAX_VALUE);
        // Use Float.toString to derive the expected string to avoid hard-coding format nuances
        assertEquals(Float.toString(Float.MAX_VALUE), max.toString());
    }

    @Test
    public void testMinValue_ReturnsExpectedString() {
        Value min = new Value.FloatValue(Float.MIN_VALUE);
        assertEquals(Float.toString(Float.MIN_VALUE), min.toString());
    }

    @Test
    public void testLargeScale_RepeatedToString_Consistent() {
        // Large-scale repetition to ensure consistent behavior across many calls.
        final int iterations = 100000;
        Value v = new Value.FloatValue(3.14159f);
        String expected = Float.toString(3.14159f);
        String last = null;
        int count = 0;

        for (int i = 0; i < iterations; i++) {
            last = v.toString();
            count++;
        }

        // Single assertion to verify consistency and that loop executed expected times
        assertEquals(expected, last);
        // Additional sanity check that the loop executed the intended number of times
        assertEquals(iterations, count);
    }
}